Fix loader correctness and global side-effects from PR #103 review - #121

Please address the comments from this code review:

## Overall Comments
- In `TestXmlLoader.mock_xml_file`, if the implementation still uses `content = content or self.file_content`, then `test_xml_loader_with_empty_file` will never actually pass an empty string ('' is falsy) and will instead use `self.file_content`; consider switching to a sentinel check (e.g., `if content is None: content = self.file_content`) so the empty-content test behaves as intended.
- The JSON loader’s file and string paths now duplicate the same `strip`/`jsonlib.loads`/`isinstance(list)` logic; consider extracting this into a shared helper to keep the behavior consistent and ease future changes.

## Individual Comments

### Comment 1
<location path="tests/_loaders/test_xml_loader.py" line_range="103-106" />
<code_context>
             self.assertRaises(StopIteration, next, data)

     def test_xml_loader_is_iterable(self):
-        with self.mock_csv_file(file_content):
+        with self.mock_xml_file(file_content):
             data = xml(file_path)
             self.assertEqual(len(list(iter(data))), 3)

     def test_xml_loader_with_empty_file(self):
</code_context>
<issue_to_address>
**suggestion (testing):** Consider adding tests for XML loader when using `read_from_src=True` with different flag combinations

With the refactor removing the global `config` and threading flags through the call chain, the `read_from_src=True` path (`_lazy_parse_xml_string`) should be covered similarly to the file-path loader.

Could you add tests that:
- Call `xml(xml_string, read_from_src=True)` with `retrieve_children` set to both `True` and `False`, checking the parsed data shape matches the existing file-based tests.
- Call `xml(xml_string, read_from_src=True, cast_types=False)` and assert numeric/boolean-like values remain strings, mirroring `test_xml_loader_no_casting`.

You can reuse the existing `file_content` XML string so both entry points (`file_path` and `read_from_src`) stay aligned without much extra test code.

Suggested implementation:

```python
    def test_xml_loader_no_casting(self):
        with self.mock_xml_file(file_content):
            data = xml(file_path, cast_types=False)

            first = next(data)
            self.assertRaises(StopIteration, next, data)

    def test_xml_loader_from_src_retrieve_children_true(self):
        # read_from_src=True should behave the same as the file-path loader
        with self.mock_xml_file(file_content):
            file_data = list(xml(file_path, retrieve_children=True))

        src_data = list(xml(file_content, read_from_src=True, retrieve_children=True))
        self.assertEqual(src_data, file_data)

    def test_xml_loader_from_src_retrieve_children_false(self):
        # read_from_src=True with retrieve_children=False should mirror file-path behaviour
        with self.mock_xml_file(file_content):
            file_data = list(xml(file_path, retrieve_children=False))

        src_data = list(xml(file_content, read_from_src=True, retrieve_children=False))
        self.assertEqual(src_data, file_data)

    def test_xml_loader_from_src_no_casting(self):
        # read_from_src=True with cast_types=False should mirror test_xml_loader_no_casting
        with self.mock_xml_file(file_content):
            file_data = list(xml(file_path, cast_types=False))

        src_data = list(xml(file_content, read_from_src=True, cast_types=False))
        self.assertEqual(src_data, file_data)

    def test_xml_loader_is_iterable(self):
        with self.mock_xml_file(file_content):
            data = xml(file_path)
            self.assertEqual(len(list(iter(data))), 3)

    def test_xml_loader_with_empty_file(self):
        with self.mock_xml_file(''):
            data = xml(file_path)
            self.assertRaises(ParseError, next, data)

```

These changes assume:
1. The `xml` loader already accepts `read_from_src` and `retrieve_children` keyword arguments, matching the refactor you mentioned.
2. `file_content` is the XML string used in other tests in this module, and `file_path`/`mock_xml_file` are available helpers as shown.

If there are existing dedicated tests for `retrieve_children=True/False` with the file-path loader earlier in this file, these new tests now assert that the `read_from_src=True` path produces identical output to the file-based path for the same flags, without needing to duplicate structure-specific assertions.
</issue_to_address>

### Comment 2
<location path="tests/_loaders/test_yaml_loader.py" line_range="67-72" />
<code_context>
             data = yaml(file_path)
             self.assertIsInstance(data, GeneratorType)

+    def test_yaml_loader_with_malformed_yaml(self):
+        malformed_yaml = "key: : invalid"
+        with self.assertRaises(yaml_lib.YAMLError):
+            list(yaml(malformed_yaml, read_from_src=True))
+
     def _check_extracted_data(self, data):
</code_context>
<issue_to_address>
**suggestion (testing):** Extend malformed YAML coverage to the file-based loader path

You’ve covered the `read_from_src=True` path. To keep behavior consistent with the other loader tests, please add a file-based variant that:

- Writes the same malformed YAML to a temp file (or uses the existing file-mocking helper).
- Calls `yaml(file_path)` without `read_from_src=True`.
- Asserts `yaml_lib.YAMLError` is raised when the generator is consumed.

This will verify that both string and file inputs fail the same way for invalid YAML.

```suggestion
    def test_yaml_loader_with_malformed_yaml(self):
        malformed_yaml = "key: : invalid"
        with self.assertRaises(yaml_lib.YAMLError):
            list(yaml(malformed_yaml, read_from_src=True))

    def test_yaml_loader_with_malformed_yaml_file_path(self):
        malformed_yaml = "key: : invalid"
        with patch(PATH_EXISTS, return_value=True), \
             patch(PATH_ISFILE, return_value=True), \
             patch(OPEN, mock_open(read_data=malformed_yaml)):
            with self.assertRaises(yaml_lib.YAMLError):
                list(yaml("malformed.yaml"))

    def _check_extracted_data(self, data):
```
</issue_to_address>